18. PHP Avanzado.
18.2. Conexión a bases de datos.
18.3. Subiendo ficheros al servidor.
18.4. Trabajando con gráficos.
18.5. Controlando al usuario con las sesiones.
18.6. Nuevas tendencias el modelo vista controlador.
18.1. Introducción.
Sobre PHP puedes encontrar numerosa documentación, véase capítulo 17 “Creando páginas dinámicas con PHP” y bibliografía. Añadiendo un capítulo más sobre este lenguaje pretendemos mostrarte las inmensas posibilidades de PHP, así, a lo largo del capítulo realizaremos un recorrido “a grandes rasgos” por las funcionalidades más significativas.
Teniendo presente que es el usuario la razón de ser de las aplicaciones Web, veremos cómo ofrecerles páginas que gestionen sus datos (acceso y consulta de base de datos), el uso de ficheros, creación de gráficos que hagan más amigable su interacción con nuestro portal, etc.
Finalmente examinaremos las actuales tendencias de programación en PHP, los frameworks y el modelo vista controlador. La lectura idónea de este capítulo pensamos que debe realizarse teniendo presente los conceptos de HTML/XHTML, CSS, JavaSript y AJAX aportando de esta manera una visión global de todas las posibilidades que nos ofrece la tecnología actual.
|
|
Asegúrate de tener habilitado el soporte de acceso a bases de datos desde PHP para MySQL. Edita el fichero php.ini y descomenta las líneas, es decir, quita el punto y coma “;” del principio:
En la sección Dynamic Extensions. |
18.2. Conexión a bases de datos.
Imagina el siguiente supuesto: tenemos que realizar una aplicación Web para la gestión de una lavandería, que permita a los operarios introducir los servicios que han realizado determinadas máquinas en un día, número de lavados que ha realizado cierta lavadora o de secados en el caso de las secadoras.
El primer paso consiste en disponer de una base de datos en la que vamos a incluir toda la información relativa al problema. Haciendo uso de MySQL y sin entrar en mucho detalle creamos una base de datos “osi” y tres tablas:
* Recurso, que contendrá la información relativa a las máquinas.
* Servicios, identifica cada tipo de servicio y el coste asociado al mismo.
* Recursoservicio, relación de las dos tablas (N:M), especifica las fechas concretas y el número de servicios realizados para cada recurso.
|
|
Para aprender a crear y gestionar bases de datos, dispones del capítulo 16 “El gestor de base de datos por excelencia, MySQL”. |
Una vez definida la infraestructura, vamos a ver como acceder a la base de datos desde PHP, el procedimiento consta de cuatro fases:
* Conexión,al sistema gestor de bases de datos, indicando los siguientes parámetros: host o equipo donde está instalado el gestor, usuario y contraseña que han de estar creados y disponer de privilegios. A continuación mostramos un detalle de la creación de usuarios con privilegios sobre una base de datos.
* Selección de la base de datos con la que deseamos trabajar. Recuerda que un gestor de base de datos, por ejemplo MySQL, normalmente dispone de varias bases de datos con las que trabajar.
* Operaciones a realizar sobre la base de datos, como pueden ser inserción de nuevos datos, consulta, borrado, etc. Esta fase la estudiaremos con detenimiento en los siguientes epígrafes.
* Cerrar, hemos de asegurarnos de gestionar correctamente las conexiones, cerrando estas una vez finalizadas sus objetivos.
Para efectuar las primeras dos fases vamos a hacer uso de las siguientes funciones:
|
mysql_connect(host, login, password) |
|
mysql_select_db("Base-de- datos") |
|
|
Veamos cómo sería el código fuente de nuestra conexión: |
|
<html> <head> <title>Conexión</title> </head> <body> <?php $servidor="127.0.0.1"; $login="osi"; $password="8sbatBscZtLLCFLG"; $conexion = mysql_connect($servidor,$login,$password) or die ("Error de conexión"); //Selección de la base de datos a utilizar mysql_select_db("osi") or die("Error de selección de base de datos"); /*Esta instrucción finaliza nuestro primer acceso a la base de datos*/ mysql_close($conexion); ?> </body> </html> |
Definimos las variables: servidor, login y password para posteriormente utilizarlas en la función mysql_connect.
Fíjate hacemos uso de la función or die, esta muestra el mensaje indicado en pantalla y finaliza el script actual si se produjo un error en la conexión.
Una vez conectados seleccionamos la base de datos con la que deseamos trabajar, utilizando la función mysql_select_db.
Por último cerramos la conexión mediante mysql_close.
|
|
Una buena práctica es crear dos ficheros externos, por ejemplo: conecta.php y cierra.php y utilizarlos en todas las páginas que necesitemos mediante la instrucción include o require. |
18.2.1. Obtención de datos.
Una vez conectados a la base de datos podemos realizar prácticamente todo tipo de operaciones. Por ejemplo, para efectuar consultas utilizaremos la función:
|
$ResultadoConsulta= mysql_query($consulta, $conexión) |
Donde:
* Consulta puede ser de cualquier tipo: inserciones, actualizaciones, borrados, etc.
* Conexión es la que previamente hemos creado.
Cuyo resultado es una matriz con los valores obtenidos. Posteriormente, en el caso de las consultas, hemos de presentar los resultados, nosotros haremos uso de la siguiente función.
|
mysql_fetch_row ($ResultadoConsulta) |
A continuación exponemos el código fuente de una consulta a la tabla servicios de nuestra base de datos.
|
<html> <head> <title>Consulta datos</title> </head> <body> <?php include "conecta.php"; $resultado=mysql_query("SELECT * FROM servicio", $conexion); echo"<table width=200 border=1> <tr> <td><b>Servicio</b></td><td><b>Coste</b></td></tr>"; while($fila=mysql_fetch_row($resultado)){ echo"<tr> <td>$fila[0]</td><td>$fila[1]</td> </tr>"; } echo"</table>"; include "cierra.php"; ?> </body> </html> |
Observa:
Para realizar la conexión y el cierre hemos utilizado la función include para llamar a los siguientes ficheros: “conecta.php” y “cierra.php”.
En la variable “$resultado” obtenemos una matriz con los datos de la consulta.
Realizamos un bucle while para ir recorriendo la matriz y mostrar los resultados mediante la función “mysql_fetch_row”.
A continuación te mostramos los ficheros, conecta.php, cierra.php y el resultado en el navegador.
conecta.php:
|
<?php $servidor="127.0.0.1"; $login="osi"; $password="8sbatBscZtLLCFLG"; $bd="osi"; $conexion = mysql_connect($servidor,$login,$password) or die ("Error de conexión"); //Selección de la base de datos a utilizar mysql_select_db("$bd") or die("Error de selección de base de datos"); ?> |
cierra.php:
|
<?php mysql_close($conexion); ?> |
|
|
18.2.2. Inserción de datos.
Para insertar datos en la base de datos, procedemos de igual manera pero cambiando la consulta, para ejecutar “Insert”. Este sería el código fuente para insertar el servicio de secado en nuestra tabla.
|
<html> <head> <title>Consulta datos</title> </head> <body> <?php include "conecta.php"; $resultado=mysql_query("Insert into servicio values ('Secado', '45')", $conexion) or die (“Error al ejecutar la consulta”); include "cierra.php"; ?> </body> </html> |
|
|
Normalmente este tipo de procesamiento es la respuesta de un formulario en el que el usuario ha introducido los datos que desea. Por lo que nuestras variables suelen pasarse como parámetros. |
18.2.3. Actualización de datos.
Al igual que la inserción, en la actualización la única diferencia es la consulta que enviamos al gestor de base de datos.
|
<html> <head> <title>Actualiza datos</title> </head> <body> <?php include "conecta.php"; $consulta ="Update servicio SET Coste = 500 where IDServicio='Secado'"; $resultado=mysql_query($consulta,$conexion) or die ("Error al ejecutar la actualización"); include "cierra.php"; ?> </body> </html> |
18.2.4. Borrado de datos.
Nos falta borrar tuplas de la base de datos, el código fuente es:
|
<html> <head> <title>Borrado de datos</title> </head> <body> <?php include "conecta.php"; $consulta ="Delete from servicio where IDServicio='Secado'"; $resultado=mysql_query($consulta,$conexion) or die ("Error al ejecutar el borrado"); include "cierra.php"; ?> </body> </html> |
18.2.5. Trabajando con procedimientos almacenados.
Los procedimientos almacenados, store procedures, son programas, scripts, que guardamos directamente en el gestor de base de datos para poder utilizarlos posteriormente. Esta filosofía tiene como principal ventaja la rapidez en las respuestas ya que los procedimientos están pre-compilados en la base de datos, por otro lado al separar la lógica de la aplicación de la presentación, incrementamos la seguridad.
En el capítulo “16” “El gestor de base de datos por excelencia MySQL” obtendrás una introducción a los procedimientos almacenados. Además en la siguiente dirección: http://dev.mysql.com/doc/refman/5.0/es/stored-procedures. html, puedes profundizar en su uso y sintaxis.
Para utilizar los procedimientos almacenados en PHP usa la función CALL. Este sería un ejemplo:
|
<html> <head> <title> Consulta datos</title> </head> <body> <?php include "conecta.php"; $consulta="CALL sp_nuevoServicio ('Secado especial', '50')"; $resultado=mysql_query($consulta, $conexion); include "cierra.php"; ?> </body> </html> |
18.2.6. Funciones de bases de datos.
En este epígrafe te mostramos las funciones más utilizadas de que dispones en PHP para operar con las bases de datos.
|
Función |
Descripción |
|
mysql_affected_rows |
Devuelve el número de filas afectadas en la última operación. |
|
mysql_change_user |
Cambia el usuario conectado en la conexión activa. |
|
mysql_close |
Cierra la conexión. |
|
mysql_connect |
Establece una conexión a un servidor. |
|
mysql_create_db |
Crea una base de datos. |
|
mysql_db_query |
Envía una sentencia SQL al servidor. |
|
mysql_drop_db |
Borra una base de datos. |
|
mysql_errno |
Retorna el número del mensaje de error de la última operación. |
|
mysql_error |
Devuelve el texto del mensaje de error de la última operación. |
|
mysql_fetch_array |
Extrae la fila de resultado como una matriz asociativa, una matriz numérica o ambas. |
|
mysql_fetch_assoc |
Recupera una fila de resultado como una matriz asociativa. |
|
mysql_fetch_field |
Extrae la información de una columna y la devuelve como un objeto. |
|
mysql_fetch_object |
Extrae una fila de resultado como un objeto. |
|
mysql_fetch_row |
Devuelve una fila de resultado. |
|
mysql_fetch_lengths |
Devuelve las longitudes de cada campo de la última fila que se ha extraído con mysql_fetch_row. |
|
mysql_field_len |
Devuelve la longitud del campo especificado. |
|
mysql_field_name |
Devuelve el nombre del campo especificado en un resultado. |
|
mysql_field_table |
Devuelve el nombre de la tabla donde está el campo especificado. |
|
mysql_field_type |
Devuelve el tipo del campo especificado en un resultado. |
|
mysql_free_result |
Libera la memoria del resultado. |
|
mysql_list_dbs |
Lista las bases de datos disponibles en el servidor. |
|
mysql_list_fields |
Lista los campos del resultado. |
|
mysql_list_tables |
Lista las tablas en una base de datos. |
|
mysql_num_fields |
Devuelve el número de campos de un resultado. |
|
mysql_num_rows |
Devuelve el número de filas de un resultado. |
|
mysql_pconnect |
Abre una conexión persistente al servidor. |
|
mysql_query |
Envía una consulta de SQL. |
|
mysql_result |
Devuelve datos de un resultado. |
|
mysql_select_db |
Selecciona una base de datos. |
|
mysql_stat |
Obtiene el status actual del sistema. |
|
mysql_tablename |
Devuelve el nombre de la tabla de un campo. |
18.3. Subiendo ficheros al servidor.
18.3.1. Consideraciones previas.
Otra operación muy común en los sitios Web es permitir al usuario enviar un fichero al servidor, fotografías, presentaciones, audios, etc. Para habilitar esta característica primero hemos de revisar el fichero php.ini:
* file_uploads: establécelo a “On”.
* upload_max_filesize, introduce el tamaño máximo que vas a permitir en los archivos del usuario.
* upload_tmp_dir, esta variable indica el directorio donde se almacenarán los ficheros; por defecto no tiene ningún valor, la puedes dejar así o especificar un directorio concreto.
18.3.2. El formulario para el usuario.
Una vez configurado el servidor, vamos manos a la obra. El proceso de subir archivos al servidor lo podemos dividir en dos fases:
La primera es crear el formulario de subida de archivos:
Tenemos que crear una página en la que el usuario pueda seleccionar el fichero que desea de su disco duro:
|
|
A continuación te mostramos el código fuente de un formulario básico para efectuar esta operación: |
|
<html><head><title>Subida de Ficheros</title></head> <body> <form enctype="multipart/form-data" action="subirarchivo.php" method="post"> <input type="hidden" name="MAX_FILE_SIZE" value="50000"> Fichero que deseas subir: <input name="archivo" type="file"> <input type="submit" value="Subir archivo"> </form> </body> </html> |
Observa el formulario:
* Hemos establecido la propiedad enctype a “multipart/form-data” indicando al navegador que vamos a realizar un Upload de archivos del usuario.
* Utilizamos el método POST y la página encargada de subir el archivo al servidor es “subirarchivo.php ”
* El formulario dispone de un input oculto “MAX_FILE_SIZE” cuyo valor es “50000”. Esto es una primera medida de seguridad para bloquear archivos de mayor tamaño.
18.3.3. Lo que el usuario no ve: El proceso en php.
|
|
Examinemos ahora el código fuente de subirarchivo.php: |
|
<html> <head> <title>Subida de Ficheros</title> </head> <body> <H1>Subida de Ficheros</H1> <br> <?php $tamano_max = $_POST['MAX_FILE_SIZE']; $archivo_name= $_FILES['archivo']['name']; $archivo_size= $_FILES['archivo']['size']; $archivo_type= $_FILES['archivo']['type']; $archivo= $_FILES['archivo']['tmp_name'];
echo "Nombre del archivo: $archivo_name<br>"; echo "Tamaño permitido por el formulario: $tamano_max<br>"; echo "Tamaño del archivo: $archivo_size<br>"; echo "Tipo de archivo: $archivo_type<br>"; if (is_uploaded_file($archivo)) { copy($archivo, $archivo_name); echo "Fichero transmitido correctamente <br>"; } else { echo "Error de transmisión del archivo $archivo_name <br>"; } ?> </body> </html> |
Recogemos los datos del formulario, para ello nuestro código PHP utiliza las variables predefinidas $_FILES. En la siguiente tabla te mostramos las distintas variables:
|
Variable |
Descripción |
|
$_FILES['userfile']['name'] |
El nombre original del fichero en la máquina cliente. |
|
$S_FILES['userfile']['type'] |
El tipo mime del fichero. |
|
$S_FILES['userfile']['size'] |
El tamaño en bytes del fichero recibido. |
Acto seguido utilizamos la función is_uploaded_file con lo que verificamos si la carga del archivo se realizó mediante HTTP POST, evitando de esta manera usuarios mal intencionados. Por último copiamos el fichero en su destino con la función copy.
|
|
Existen en Internet multitud de ejemplos de Upload de ficheros, con distintas comprobaciones y tipos de ficheros. Puedes googlear un rato con los conocimientos recién adquiridos para adaptar alguna versión que se ajuste a tus requerimientos específicos. |
18.4. Trabajando con gráficos.
PHP permite el tratamiento de imágenes y gráficos. Existen numerosas funciones y utilidades para tratar con este tipo de ficheros, especialmente útiles son las librerías para crear diagramas estadísticos y creación de galerías gráficas. En las siguientes direcciones puedes obtener un listado de las funciones disponibles para el tratamiento de imágenes y creación de galerías fotográficas:
* http://es.php.net/gd, funciones y recursos para trabajar con imágenes.
* http://naku.dohcrew.com/libchart/pages/introduction/. Excelente librería GNU para crear gráficos estadísticos.
* http://www.desarrolloweb.com/scripts/php/trabajo-imagenes-php.php
Una gran cantidad de recursos para trabajar con imágenes.
Creemos un ejemplo simple. La primera acción que tienes que llevar a cabo es verificar si dispones de soporte para tratar con este tipo de ficheros. Accede a la página “info.php” de tu servidor y verifica la sección GD.
Fíjate tienes que tener activado el soporte, también se muestra información de los distintos tipos de ficheros que soporta. Si este no es tu caso, edita el fichero php.ini y descomenta la extensión, php_gd2.dll.
Ahora vamos a crear una página HTML/XHTML en la que insertar nuestros gráficos. Este es el código fuente.
|
<html> <head></head> <title>Guía del perfecto Webmaster.</title> <body> <h1>Ejemplo básico Imágenes</h1> <hr /> <table border=1> <tr> <td>Rectángulo azul</td> <td>Circunferencia roja</td> <td>Polígono verde</td> </tr> <tr> <td><img src="imagen2.php"></td> <td><img src="imagen3.php"></td> <td><img src="imagen.php"></td> </tr> </table> </body> </html> |
El código es simple, creamos una tabla, en la que insertar las imágenes, mediante la etiqueta <img>. Llamamos a los scripts correspondientes:
* “imagen2.php ”. Para dibujar un rectángulo azul.
* “imagen3.php ”. Una circunferencia roja.
* “imagen.php ” En este caso, un polígono verde.
Examinemos la página “imagen2.php”:
|
<?php Header("Content-type: image/png"); //Creamos la imagen $imagen = ImageCreate(100, 100); //Definimos el color $fondo =imagecolorallocate ($imagen,0,0,100); //Pintamos el fondo Imagefill ($imagen,0,0,$fondo); //Mostramos la imagen ImagePng($imagen); //Liberamos memoria Imagedestroy($imagen); ?> |
* Con la primera instrucción: Header("Content-type: image/png"); especificamos que tipo de imagen vamos a enviar al navegador.
* Creamos la imagen “$imagen” con la función: ImageCreate(100, 100); en la que indicamos el tamaño de la misma.
* Seguidamente creamos un color con la función: imagecolorallocate($imagen,0,0,100); cuyos parámetros son la imagen y la definición del color mediante tres valores RGB (rojo, verde y azul).
* Con Imagefill realizamos un relleno de la imagen, en las coordenadas especificadas y con el color pasado como parámetro.
* Ahora, mostramos la imagen en el navegador con ImagePng.
* Por último liberamos de la memoria la imagen mediante la función Imagedestroy($imagen);
|
|
En los ejemplos utilizados en éste epígrafe hemos usado funciones para imágenes png. Si deseas utilizar otro tipo de funciones recuerda que has de cambiar la cabecera Header("Content-type:image/png"), además la sintaxis de las funciones varía. |
Para crear la circunferencia roja procedemos de igual manera, salvo que utilizamos la siguiente función:
imagearc($imagen, 100, 100, 150, 150, 0, 360, $linea); que dibuja una elipse, en la variable $imagen, cuyo centro es la coordenada “100, 100” , anchura “150”, altura “150”, con lo que tenemos una circunferencia cuyos puntos de inicio y final son 0 y 360 especificados en grados y el color es la variable $linea. Éste es el código fuente del script:
|
<?php header("Content-type: image/png"); // Creamos imagen $imagen = imagecreate(200, 200); // Definimos colores $fondo = imagecolorallocate($imagen, 255, 255, 255); $linea = imagecolorallocate($imagen, 255, 0, 0); // Dibujamos círculo imagearc($imagen, 100, 100, 150, 150, 0, 360, $linea); //Mostar imagen imagepng($imagen); // liberar la memoria imagedestroy($imagen); ?> |
Nos queda el polígono. En este caso, tenemos que especificar las coordenadas de sus vértices (un par X, Y), mediante una matriz ($vertices) y utilizar la función: ImagePolygon($imagen, $vertices, 7, $azul). A continuación puedes ver el código fuente y el resultado en el navegador:
|
<?php Header("Content-type: image/png"); //Creamos la imagen. $imagen = ImageCreate(300, 300); //Definimos colores $verde = ImageColorAllocate($imagen, 0, 255, 0); $blanco = ImageColorAllocate($imagen, 255, 255, 255); $azul = ImageColorAllocate($imagen, 0, 0, 255); // Definimos vértices por pares. $vertices = Array(150, 10, 250, 100, 250, 200, 50, 200, 50, 100, 80, 150, 110, 80); //Ponemos el fondo blanco ImageFill($imagen, 0, 0, $blanco); //Dibujamos un polígono con 7 vértices ImagePolygon($imagen, $vertices, 7, $azul); //Rellenamos el pentágono de verde y lo bordeamos por azul ImageFillToBorder($imagen, 150, 150, $azul, $verde); //Mostramos imagen ImagePng($imagen); //Liberamos memoria Imagedestroy($imagen); ?> |
18.4.1. Creando estadísticas profesionales con Libchart.
Vamos a mostrarte una librería que nosotros utilizamos frecuentemente por su simplicidad y potencia, Libchart. Dirígete a la dirección http://naku.dohcrew.com/libchart/pages/introduction/ y descarga la última versión.
Descomprímela en un directorio público de tu servidor Web. Ahora ya puedes utilizarla. Fíjate que son dos carpetas: la librería en sí y los ficheros de ejemplo “demo”.
Ahora ya sólo tenemos que crear el gráfico teniendo en cuenta que deseamos utilizar la librería recién instalada: include “ruta del archivo libchar.php”. En la propia página de Libchar dispones de buenos ejemplos y en la carpeta demo puedes ver algunos y modificarlos a tu gusto y necesidades. Aquí tienes un ejemplo:
|
<?php include "../libchart/classes/libchart.php"; /*Creamos un objeto barra horizontal, disponemos de barras verticales VerticalBarChart, gráficos de líneas LineChart y tartas o quesitos, PieChart */ $chart = new HorizontalBarChart(450, 250); //Creamos cinco barras y las añadimos en un data set, conjunto de datos. $serie1 = new XYDataSet(); //Cada barra está formada por un par etiqueta, valor $serie1->addPoint(new Point("0-2", 2)); $serie1->addPoint(new Point("2-4", 7)); $serie1->addPoint(new Point("4-6", 10)); $serie1->addPoint(new Point("6-8", 5)); $serie1->addPoint(new Point("8-10", 2)); $dataSet = new XYSeriesDataSet(); $dataSet->addSerie("Nº de Alumnos", $serie1); //Vinculamos el conjunto de datos al gráfico $chart->setDataSet($dataSet); //Asignamos un título al gráfico y lo mostramos $chart->setTitle("Notas del trimestre"); $chart->render("generated/grafico.png"); ?> <html> <head> <title>LibChar: Ejemplo</title> </head> <body> <img alt="Gráfico de barras" src="generated/grafico.png" style="border: 1px solid gray;"/> </body> </html> |
18.5. Controlando al usuario con las sesiones.
En numerosas ocasiones necesitamos controlar cuales han sido las opciones elegidas por el usuario durante su navegación por nuestro portal Web, como puede ser la implementación de un carrito de la compra. Para realizar esta tareas puedes hacer uso de las Cookies o mejor aún utilizar las sesiones en el servidor.
|
|
Una Cookie, galletita es un archivo con información que se almacena en el disco duro de los visitantes de las páginas Web. |
Las sesiones son un mecanismo para almacenar información de los visitantes en el servidor mientras dura su visita a nuestro portal Web. De tal manera que para cada usuario que nos visite se abrirá una sesión y permanecerá activa hasta que abandone el lugar.
Para guardar esta información hemos de utilizar las variables de sesión y las páginas han de estar escritas en PHP, “no HTML/XHTML”, es decir, nuestras páginas se han de llamar “loquesea.php”.
|
|
En la siguiente dirección Web puedes encontrar información actualizada sobre las sesiones, así como las funciones disponibles: http://es.php.net/session. |
Veamos un ejemplo:
Las funciones que vamos a utilizar son las siguientes:
* session_start(). Creamos una sesión nueva o continuamos con una existente. Para registrar las variables de sesión hacemos uso de la matriz $_SESSION.
* session_unset(). Elimina las variables registradas. Esto debe realizarse antes de cerrar la sesión.
* session_destroy(). Cerramos la sesión.
|
<?php //Inicialización de la sesión session_start(); ?> <html> <head> <title>Generar variables de sesión</title> </head> <body> <?php //Definimos las variables de sesión $_SESSION["Nombre"] = "Joe"; $_SESSION["Edad"] = "33"; ?> <h1> Ejemplo de sesiones</h1> <a href="sesion2.php"> Pulsa para comprobar las variables de sesión</a> </body> </html> |
El ejemplo consta de dos páginas: “sesion.php” y “sesion2.php”. En la primera creamos la sesión y registramos las variables “nombre” y “edad”, para posteriormente en la segunda página recoger el valor de las variables de sesión, eliminar las variables y finalmente destruir la sesión.
|
<?php //inicializo la sesión o continuo con la creada anteriormente, session_start(); ?> <html> <head> <title>Ejemplo de sesiones</title> </head> <body> Muestro el valor de las variables registradas:</br> <?php echo $_SESSION["Nombre"]."</br>"; echo $_SESSION["Edad"]. "</br>"; // Eliminar las variables registradas session_unset(); // Destruye la sesión session_destroy(); ?> </body> </html> |
18.6. Nuevas tendencias el modelo vista controlador.
La construcción de sitios Web ha evolucionado considerablemente, actualmente aplicando principios de ingeniería del software, los sitios profesionales se diseñan siguiendo el modelo vista controlador.
En este modelo se definen tres partes claramente diferenciadas:
* La Vista, donde el usuario interactúa con la aplicación, suele escribirse en XHTML/HTML y CSS.
* El modelo, encargado de gestionar los datos de la aplicación, lógica de la aplicación, usualmente un gestor de base de datos como MySQL.
* El controlador, el cual sirve de nexo, unión entre la vista y el modelo, gestionando los eventos del usuario.
|
|
El modelo vista controlador MVC mejora la usabilidad de las aplicaciones y permite una mayor reutilización de código. |
18.6.1. Un Frameworks para PHP: Symfony.
En la actualidad disponemos de muchos frameworks que nos ayudan para la construcción de aplicaciones siguiendo el modelo vista controlador. En la siguiente dirección puedes consultar la mayoría de ellos:
http://es.wikipedia.org/wiki/Modelo_Vista_Controlador.
|
|
Un framework, armazón, es una estructura de soporte para el desarrollo de software, suele estar constituida por librerías y utilidades. |
Dentro de los que se desarrollan en PHP nos encontramos con Symfony cuya página principal del proyecto es http://www.symfony-project.org/. Se trata de un proyecto Open Source que ha sido en los últimos años bastante popular. Aquí encontrarás toda la documentación necesaria para empezar a elaborar tus proyectos, merece la pena revisar la sección Jobeet, donde te explican paso a paso en 24 sesiones como montar una aplicación Web desde cero: http://www.symfony-project.org/jobeet/1_2/Doctrine/en/.